package EcologicalBinPacking102;


import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {

    private static int contenedores[][], combinados[][];
    private static Scanner consola = new Scanner(System.in);
    private static StringTokenizer st;
    private static StringBuilder sb;

    public static void main(String args[]) {
        while (consola.hasNextLine()) {
            combinados = new int[6][2];
            /*Esta matriz representa todas las combinaciones posibles
             * 0 BCG | "valores"
             * 1 BGC | "valores"
             * 2 CBG | "valores"
             * 3 CGB | "valores"
             * 4 GBC | "valores"
             * 5 GCB | "valores"
             */
            combinados[0][0] = 6;
            combinados[1][0] = 5;
            combinados[2][0] = 4;
            combinados[3][0] = 3;
            combinados[4][0] = 2;
            combinados[5][0] = 1;


            contenedores = new int[3][4];
            sb = new StringBuilder();
            st = new StringTokenizer(consola.nextLine());

            cargarcontenedores();

            calcularCombinados();
            int indice = mayorCombinado();
            armarString(indice);


            System.out.print(sb.toString());
            //if (consola.hasNextLine()) {
            System.out.print("\n");
            //}
        }
    }

    private static void armarString(int indice) {
        switch (indice) {
                case 0:
                    sb.append("BCG ");
                    break;
                case 1:
                    sb.append("BGC ");
                    break;
                case 2:
                    sb.append("CBG ");
                    break;
                case 3:
                    sb.append("CGB ");
                    break;
                case 4:
                    sb.append("GBC ");
                    break;
                case 5:
                    sb.append("GCB ");
                    break;
            }
        sb.append(combinados[indice][1]);
    }

    private static int mayorCombinado() {
        int indice = 5, cantMenor = combinados[5][1];
        for (int i = 0; i < 6; i++) {
            if (combinados[i][1] < cantMenor) {
                cantMenor = combinados[i][1];
                indice = i;
            } else {
                if (combinados[i][1] == cantMenor) {
                    if (combinados[i][0] > combinados[indice][0]) {
                        indice = i;
                    }
                }
            }
        }
        return indice;
    }

    private static void calcularCombinados() {
        for (int i = 0; i < 6; i++) {
            switch (i) {
                case 0:
                    combinados[i][1] = calcularSobras(0, 1) + calcularSobras(1, 3) + calcularSobras(2, 2);
                    break;
                case 1:
                    combinados[i][1] = calcularSobras(0, 1) + calcularSobras(1, 2) + calcularSobras(2, 3);
                    break;
                case 2:
                    combinados[i][1] = calcularSobras(0, 3) + calcularSobras(1, 1) + calcularSobras(2, 2);
                    break;
                case 3:
                    combinados[i][1] = calcularSobras(0, 3) + calcularSobras(1, 2) + calcularSobras(2, 1);
                    break;
                case 4:
                    combinados[i][1] = calcularSobras(0, 2) + calcularSobras(1, 1) + calcularSobras(2, 3);
                    break;
                case 5:
                    combinados[i][1] = calcularSobras(0, 2) + calcularSobras(1, 3) + calcularSobras(2, 1);
                    break;
            }
        }
    }

    private static int calcularSobras(int contenedor, int color) {
        int r = 0;
        for (int i = 1; i <= 3; i++) {
            if (i != color) {
                r += contenedores[contenedor][i];
            }
        }
        return r;
    }

    private static void cargarcontenedores() {
        for (int i = 0; i < 3; i++) {//Contenedores
            for (int j = 1; j <= 3; j++) {//Colores
                switch (j) {
                    case 1:
                        contenedores[i][j] = Integer.parseInt(st.nextToken());
                        break;
                    case 2:
                        contenedores[i][j] = Integer.parseInt(st.nextToken());
                        break;
                    case 3:
                        contenedores[i][j] = Integer.parseInt(st.nextToken());
                        break;
                }

            }
        }
    }
}
